TypeScript OOP பேட்டர்ன்கள்: வகுப்பு வடிவமைப்பு மற்றும் மரபுரிமை உத்திகளுக்கான ஒரு கையேடு

நவீன மென்பொருள் உருவாக்க உலகில், TypeScript வலுவான, அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கான ஒரு மூலக்கல்லாக உருவெடுத்துள்ளது. ஜாவாஸ்கிரிப்டின் மேல் கட்டப்பட்ட அதன் வலுவான தட்டச்சு அமைப்பு, பிழைகளை முன்கூட்டியே கண்டறிந்து மேலும் கணிக்கக்கூடிய குறியீட்டை எழுத டெவலப்பர்களுக்கு கருவிகளை வழங்குகிறது. TypeScript இன் சக்தியின் மையத்தில் பொருள் நோக்கு நிரலாக்கத்திற்கான (OOP) விரிவான ஆதரவு உள்ளது. இருப்பினும், ஒரு வகுப்பை எவ்வாறு உருவாக்குவது என்பதை அறிவது மட்டும் போதாது. TypeScript ஐ மாஸ்டரிங் செய்வதற்கு வகுப்பு வடிவமைப்பு, மரபுரிமை படிநிலைகள் மற்றும் வெவ்வேறு கட்டமைப்பு முறைகளுக்கு இடையிலான வர்த்தகங்கள் பற்றிய ஆழமான புரிதல் தேவைப்படுகிறது.

இந்த வழிகாட்டி இடைநிலை திறன்களை உறுதிப்படுத்துபவர்கள் முதல் அனுபவமுள்ள கட்டிடக் கலைஞர்கள் வரை டெவலப்பர்களின் உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. TypeScript இல் OOP இன் முக்கிய கருத்துக்களில் ஆழமாக மூழ்கி, பயனுள்ள வகுப்பு வடிவமைப்பு உத்திகளை ஆராய்வோம், மேலும் பழமையான விவாதத்தை எதிர்கொள்வோம்: மரபுரிமை எதிராக கலவை. முடிவில், சுத்தமான, நெகிழ்வான மற்றும் எதிர்காலத்தை நிரூபிக்கும் குறியீடு தளங்களுக்கு வழிவகுக்கும் தகவலறிந்த வடிவமைப்பு முடிவுகளை எடுக்க தேவையான அறிவுடன் நீங்கள் ஆயுதம் ஏந்தியிருப்பீர்கள்.

TypeScript இல் OOP இன் தூண்களைப் புரிந்துகொள்வது

சிக்கலான முறைகளை ஆராய்வதற்கு முன், TypeScript க்கு பொருந்தும் பொருள் நோக்கு நிரலாக்கத்தின் நான்கு அடிப்படை தூண்களை மீண்டும் பார்வையிடுவதன் மூலம் ஒரு உறுதியான அடித்தளத்தை நிறுவுவோம்.

1. உறையவைத்தல்

உறையவைத்தல் என்பது ஒரு பொருளின் தரவு (பண்புகள்) மற்றும் அந்த தரவில் செயல்படும் முறைகளை ஒரு வகுப்பாக ஒரு அலகுக்குள் தொகுக்கும் கொள்கையாகும். இது ஒரு பொருளின் உள் நிலைக்கு நேரடி அணுகலைக் கட்டுப்படுத்துவதையும் உள்ளடக்குகிறது. TypeScript இதை முக்கியமாக அணுகல் மாற்றிகள் மூலம் அடைகிறது: public, private, மற்றும் protected.

உதாரணம்: ஒரு வங்கிக் கணக்கு, அங்கு டெபாசிட் மற்றும் திரும்பப் பெறும் முறைகள் மூலம் மட்டுமே இருப்பை மாற்ற முடியும்.

            class BankAccount {
  private balance: number = 0;

  constructor(initialBalance: number) {
    if (initialBalance >= 0) {
      this.balance = initialBalance;
    }
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this.balance}`);
    }
  }

  public getBalance(): number {
    // We expose the balance through a method, not directly
    return this.balance;
  }
}
            

              
                Copy
              
            
          

2. அருவமாக்கம்

அருவமாக்கம் என்றால் சிக்கலான செயலாக்க விவரங்களை மறைத்து, ஒரு பொருளின் அத்தியாவசிய அம்சங்களை மட்டுமே வெளிப்படுத்துவது. அடிப்பகுதியில் உள்ள சிக்கலான இயந்திரத்தை புரிந்து கொள்ள வேண்டிய அவசியமின்றி உயர் மட்ட கருத்துக்களுடன் வேலை செய்ய இது அனுமதிக்கிறது. TypeScript இல், அருவமாக்கம் பெரும்பாலும் abstract வகுப்புகள் மற்றும் interfaces ஐப் பயன்படுத்தி அடையப்படுகிறது.

உதாரணம்: நீங்கள் ரிமோட் கண்ட்ரோலைப் பயன்படுத்தும் போது, நீங்கள் "பவர்" பொத்தானை அழுத்தவும். அகச்சிவப்பு சிக்னல்கள் அல்லது உள் சுற்றுகளைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டியதில்லை. ரிமோட் டிவியின் செயல்பாட்டிற்கு ஒரு சுருக்கமான இடைமுகத்தை வழங்குகிறது.

3. மரபுரிமை

மரபுரிமை என்பது ஒரு புதிய வகுப்பு (துணை வகுப்பு அல்லது பெறப்பட்ட வகுப்பு) இருக்கும் வகுப்பிலிருந்து (மேற்பார்வைக் வகுப்பு அல்லது அடிப்படை வகுப்பு) பண்புகள் மற்றும் முறைகளைப் பெறும் ஒரு பொறிமுறையாகும். இது குறியீடு மறுபயன்பாட்டை ஊக்குவிக்கிறது மற்றும் வகுப்புகளுக்கு இடையே ஒரு தெளிவான "is-a" உறவை நிறுவுகிறது. TypeScript மரபுரிமைக்கு extends முக்கிய சொல்லைப் பயன்படுத்துகிறது.

உதாரணம்: ஒரு `மேலாளர்` `ஊழியரின்` ஒரு வகை "is-a". அவர்கள் `பெயர்` மற்றும் `id` போன்ற பொதுவான பண்புகளைப் பகிர்ந்து கொள்கிறார்கள், ஆனால் `மேலாளருக்கு` `கீழ்ப்படிந்தவர்கள்` போன்ற கூடுதல் பண்புகள் இருக்கலாம்.

            class Employee {
  constructor(public name: string, public id: number) {}

  getProfile(): string {
    return `Name: ${this.name}, ID: ${this.id}`;
  }
}

class Manager extends Employee {
  constructor(name: string, id: number, public subordinates: Employee[]) {
    super(name, id); // Call the parent constructor
  }

  // Managers can also have their own methods
  delegateTask(): void {
    console.log(`${this.name} is delegating tasks.`);
  }
}
            

              
                Copy
              
            
          

4. பலஉருவாக்கம்

பாலிமார்பிசம், அதாவது "பல வடிவங்கள்", வெவ்வேறு வகுப்புகளைச் சேர்ந்த பொருட்களை ஒரு பொதுவான மேற்பார்வை வகுப்பின் பொருள்களாகக் கருத அனுமதிக்கிறது. இது ஒரு முறையானது (முறை பெயர் போன்றவை) வெவ்வேறு அடிப்படை வடிவங்களை (செயலாக்கங்கள்) குறிக்க உதவுகிறது. இது பெரும்பாலும் முறை மேலெழுதல் மூலம் அடையப்படுகிறது.

உதாரணம்: ஒரு `வட்டம்` பொருளுக்கும் `சதுரம்` பொருளுக்கும் `Shape` ஆக இருந்தாலும் `render()` முறை வேறுவிதமாக செயல்படுகிறது.

            abstract class Shape {
  abstract draw(): void; // An abstract method must be implemented by subclasses
}

class Circle extends Shape {
  draw(): void {
    console.log("Drawing a circle.");
  }
}

class Square extends Shape {
  draw(): void {
    console.log("Drawing a square.");
  }
}

function renderShapes(shapes: Shape[]): void {
  shapes.forEach(shape => shape.draw()); // Polymorphism in action!
}

const myShapes: Shape[] = [new Circle(), new Square()];
renderShapes(myShapes);
// Output:
// Drawing a circle.
// Drawing a square.
            

              
                Copy
              
            
          

பெரிய விவாதம்: மரபுரிமை vs கலவை

OOP இல் இது மிக முக்கியமான வடிவமைப்பு முடிவுகளில் ஒன்றாகும். நவீன மென்பொருள் பொறியியலில் பொதுவான ஞானம் "மரபுரிமையை விட கலவையை விரும்புகிறேன்." இரண்டு கருத்துகளையும் ஆழமாக ஆராய்வதன் மூலம் ஏன் என்பதைப் புரிந்துகொள்வோம்.

மரபுரிமை என்றால் என்ன? "is-a" உறவு

மரபுரிமை அடிப்படை வகுப்புக்கும் பெறப்பட்ட வகுப்புக்கும் இடையே ஒரு இறுக்கமான இணைப்பை உருவாக்குகிறது. நீங்கள் `extends` ஐப் பயன்படுத்தும் போது, புதிய வகுப்பு அடிப்படை வகுப்பின் ஒரு சிறப்பு பதிப்பு என்று கூறுகிறீர்கள். ஒரு தெளிவான படிநிலை உறவு இருக்கும்போது இது குறியீடு மறுபயன்பாட்டிற்கான ஒரு சக்திவாய்ந்த கருவியாகும்.

• நன்மைகள்:
  • குறியீடு மறுபயன்பாடு: பொதுவான தர்க்கம் அடிப்படை வகுப்பில் ஒரு முறை வரையறுக்கப்படுகிறது.
  • பாலிமார்பிசம்: எங்கள் `Shape` எடுத்துக்காட்டில் காணப்படுவது போல், நேர்த்தியான, பாலிமார்பிக் நடத்தைக்கு அனுமதிக்கிறது.
  • தெளிவான படிநிலை: இது ஒரு நிஜ உலக, மேல்-கீழ் வகைப்பாடு முறையை மாதிரியாகக் கொண்டுள்ளது.
• தீமைகள்:
  • இறுக்கமான இணைத்தல்: அடிப்படை வகுப்பில் ஏற்படும் மாற்றங்கள் பெறப்பட்ட வகுப்புகளைத் தற்செயலாக உடைக்கக்கூடும். இது "எளிதில் உடையக்கூடிய அடிப்படை வகுப்பு சிக்கல்" என்று அழைக்கப்படுகிறது.
  • படிநிலை நரகம்: அதிகப்படியான பயன்பாடு ஆழமான, சிக்கலான மற்றும் கடினமான மரபுரிமை சங்கிலிகளுக்கு வழிவகுக்கும், அவை புரிந்துகொள்ளவும் பராமரிக்கவும் கடினமாக இருக்கும்.
  • நெகிழ்வற்ற: TypeScript இல் ஒரு வகுப்பு ஒரு வகுப்பிலிருந்து மட்டுமே மரபுரிமையாக இருக்க முடியும் (ஒற்றை மரபுரிமை), இது கட்டுப்படுத்தும். பல தொடர்பில்லாத வகுப்புகளிலிருந்து நீங்கள் அம்சங்களை மரபுரிமையாகப் பெற முடியாது.

எப்போது மரபுரிமை ஒரு நல்ல தேர்வு?

உறவு உண்மையாகவே "is-a" ஆக இருக்கும்போது மற்றும் அது நிலையானதாகவும் மாற வாய்ப்பில்லாததாகவும் இருக்கும்போது மரபுரிமையைப் பயன்படுத்தவும். எடுத்துக்காட்டாக, `CheckingAccount` மற்றும் `SavingsAccount` இரண்டும் அடிப்படையில் `BankAccount` வகைகள். இந்த படிநிலை அர்த்தமுள்ளதாக இருக்கிறது மற்றும் மறுவடிவமைக்கப்பட வாய்ப்பில்லை.

கலவை என்றால் என்ன? "has-a" உறவு

கலவை என்பது சிறிய, சுயாதீனமான பொருள்களிலிருந்து சிக்கலான பொருட்களை உருவாக்குவதை உள்ளடக்குகிறது. ஒரு வகுப்பு வேறு ஏதாவது இருப்பதற்குப் பதிலாக, அதற்கு தேவையான செயல்பாட்டை வழங்கும் பிற பொருட்களை கொண்டிருக்கிறது. இது ஒரு தளர்வான இணைப்பை உருவாக்குகிறது, ஏனெனில் வகுப்பு கலந்த பொருட்களின் பொது இடைமுகத்துடன் மட்டுமே தொடர்பு கொள்கிறது.

• நன்மைகள்:
  • நெகிழ்வுத்தன்மை: கலந்த பொருட்களை மாற்றுவதன் மூலம் செயல்பாட்டை இயக்க நேரத்தில் மாற்றலாம்.
  • தளர்வான இணைத்தல்: வகுப்புக்கு அது பயன்படுத்தும் கூறுகளின் உள் வேலைகளைத் தெரிந்து கொள்ள வேண்டிய அவசியமில்லை. இது குறியீட்டைச் சோதித்து பராமரிக்க எளிதாக்குகிறது.
  • படிநிலை சிக்கல்களைத் தவிர்க்கிறது: சிக்கலான மரபுரிமை மரத்தை உருவாக்காமல் பல்வேறு ஆதாரங்களில் இருந்து செயல்பாடுகளை இணைக்க முடியும்.
  • தெளிவான பொறுப்புகள்: ஒவ்வொரு கூறு வகுப்பும் ஒற்றை பொறுப்பு கொள்கைக்கு கட்டுப்படலாம்.
• தீமைகள்:
  • அதிக கொதிகலன்: எளிய மரபுரிமை மாதிரியுடன் ஒப்பிடும்போது வெவ்வேறு கூறுகளை வயரிங் செய்ய சில நேரங்களில் அதிக குறியீடு தேவைப்படலாம்.
  • படிநிலைகளுக்கு குறைவான உள்ளுணர்வு: இது மரபுரிமை செய்வது போல் இயற்கை வகைப்பாடுகளை நேரடியாக மாதிரியாகக் கொள்ளாது.

ஒரு நடைமுறை உதாரணம்: கார்

ஒரு `கார்` என்பது கலவையின் சரியான எடுத்துக்காட்டு. ஒரு `கார்` என்பது `எஞ்சின்` வகையும் அல்ல, `சக்கரம்` வகையும் அல்ல. அதற்கு பதிலாக, ஒரு `கார்` ஒரு `எஞ்சினை கொண்டுள்ளது`, மற்றும் `சக்கரங்களை கொண்டுள்ளது`.

            // Component classes
class Engine {
  start() {
    console.log("Engine starting...");
  }
}

class GPS {
  navigate(destination: string) {
    console.log(`Navigating to ${destination}...`);
  }
}

// The composite class
class Car {
  private readonly engine: Engine;
  private readonly gps: GPS;

  constructor() {
    // The Car creates its own parts
    this.engine = new Engine();
    this.gps = new GPS();
  }

  driveTo(destination: string) {
    this.engine.start();
    this.gps.navigate(destination);
    console.log("Car is on its way.");
  }
}

const myCar = new Car();
myCar.driveTo("New York City");
            

              
                Copy
              
            
          

இந்த வடிவமைப்பு மிகவும் நெகிழ்வானது. `எலக்ட்ரிக் எஞ்சினுடன்` ஒரு `கார்` உருவாக்க விரும்பினால், எங்களுக்கு ஒரு புதிய மரபுரிமை சங்கிலி தேவையில்லை. அதன் கூறுகளுடன் `கார்` வழங்க சார்பு ஊசி பயன்படுத்தலாம், இது இன்னும் மட்டுப்படுத்தப்பட்டதாக இருக்கும்.

            interface IEngine {
  start(): void;
}

class PetrolEngine implements IEngine {
  start() { console.log("Petrol engine starting..."); }
}

class ElectricEngine implements IEngine {
  start() { console.log("Silent electric engine starting..."); }
}

class AdvancedCar {
  // The car depends on an abstraction (interface), not a concrete class
  constructor(private engine: IEngine) {}

  startJourney() {
    this.engine.start();
    console.log("Journey has begun.");
  }
}

const tesla = new AdvancedCar(new ElectricEngine());
tesla.startJourney();

const ford = new AdvancedCar(new PetrolEngine());
ford.startJourney();
            

              
                Copy
              
            
          

TypeScript இல் மேம்பட்ட உத்திகள் மற்றும் முறைகள்

மரபுரிமை மற்றும் கலவை ஆகியவற்றுக்கு இடையேயான அடிப்படைத் தேர்வுக்கு அப்பால், அதிநவீன மற்றும் நெகிழ்வான வகுப்பு வடிவமைப்புகளை உருவாக்க TypeScript சக்திவாய்ந்த கருவிகளை வழங்குகிறது.

1. சுருக்க வகுப்புகள்: மரபுரிமைக்கான வரைபடம்

உங்களுக்கு ஒரு வலுவான "is-a" உறவு இருக்கும்போது, அடிப்படை வகுப்புகளைத் தாங்களாகவே உடனடியாக உருவாக்க முடியாது என்பதை உறுதிப்படுத்த விரும்பினால், `abstract` வகுப்புகளைப் பயன்படுத்தவும். அவை ஒரு வரைபடமாக செயல்படுகின்றன, பொதுவான முறைகள் மற்றும் பண்புகளை வரையறுக்கின்றன, மேலும் பெறப்பட்ட வகுப்புகள் செயல்படுத்த வேண்டும் `abstract` முறைகளை அறிவிக்க முடியும்.

பயன்பாட்டு நிகழ்வு: கட்டண செயலாக்க அமைப்பு. ஒவ்வொரு நுழைவாயிலும் `pay()` மற்றும் `refund()` முறைகளைக் கொண்டிருக்க வேண்டும் என்பது உங்களுக்குத் தெரியும், ஆனால் செயலாக்கம் ஒவ்வொரு வழங்குநருக்கும் (எ.கா., Stripe, PayPal) குறிப்பிட்டது.

            abstract class PaymentGateway {
  constructor(public apiKey: string) {}

  // A concrete method shared by all subclasses
  protected connect(): void {
    console.log("Connecting to payment service...");
  }

  // Abstract methods that subclasses must implement
  abstract processPayment(amount: number): boolean;
  abstract issueRefund(transactionId: string): boolean;
}

class StripeGateway extends PaymentGateway {
  processPayment(amount: number): boolean {
    this.connect();
    console.log(`Processing ${amount} via Stripe.`);
    return true;
  }

  issueRefund(transactionId: string): boolean {
    console.log(`Refunding transaction ${transactionId} via Stripe.`);
    return true;
  }
}

// const gateway = new PaymentGateway("key"); // Error: Cannot create an instance of an abstract class.
const stripe = new StripeGateway("sk_test_123");
stripe.processPayment(100);
            

              
                Copy
              
            
          

2. இடைமுகங்கள்: நடத்தைக்கான ஒப்பந்தங்களை வரையறுத்தல்

TypeScript இல் உள்ள இடைமுகங்கள் ஒரு வகுப்பின் வடிவத்திற்கான ஒப்பந்தத்தை வரையறுப்பதற்கான ஒரு வழியாகும். ஒரு வகுப்பில் என்ன பண்புகள் மற்றும் முறைகள் இருக்க வேண்டும் என்பதைக் குறிப்பிடுகின்றன, ஆனால் அவை எந்த செயலாக்கத்தையும் வழங்கவில்லை. ஒரு வகுப்பு பல இடைமுகங்களை `செயல்படுத்தலாம்`, இது கலவை மற்றும் பிரிக்கப்பட்ட வடிவமைப்பின் ஒரு மூலக்கல்லாக ஆக்குகிறது.

இடைமுகம் எதிர் சுருக்க வகுப்பு

• பல நெருங்கிய தொடர்புடைய வகுப்புகளுக்கு இடையில் செயல்படுத்தப்பட்ட குறியீட்டைப் பகிர விரும்பினால் சுருக்க வகுப்பைப் பயன்படுத்தவும்.
• வெவ்வேறு, தொடர்பில்லாத வகுப்புகளால் செயல்படுத்தப்படக்கூடிய நடத்தைக்கான ஒப்பந்தத்தை வரையறுக்க விரும்பினால் இடைமுகத்தைப் பயன்படுத்தவும்.

பயன்பாட்டு நிகழ்வு: ஒரு அமைப்பில், பலவிதமான பொருட்கள் ஒரு சரம் வடிவமைப்பிற்கு வரிசைப்படுத்தப்பட வேண்டும் (எ.கா., உள்நுழைவு அல்லது சேமிப்பகத்திற்கு). இந்த பொருள்கள் (`பயனர்`, `தயாரிப்பு`, `ஆர்டர்`) தொடர்பில்லாதவை, ஆனால் ஒரு பொதுவான திறனைப் பகிர்ந்து கொள்கின்றன.

            interface ISerializable {
  serialize(): string;
}

class User implements ISerializable {
  constructor(public id: number, public name: string) {}

  serialize(): string {
    return JSON.stringify({ id: this.id, name: this.name });
  }
}

class Product implements ISerializable {
  constructor(public sku: string, public price: number) {}

  serialize(): string {
    return JSON.stringify({ sku: this.sku, price: this.price });
  }
}

function logItems(items: ISerializable[]): void {
  items.forEach(item => {
    console.log("Serialized item:", item.serialize());
  });
}

const user = new User(1, "Alice");
const product = new Product("TSHIRT-RED", 19.99);
logItems([user, product]);
            

              
                Copy
              
            
          

3. கலவைகள்: குறியீடு மறுபயன்பாட்டிற்கான ஒரு கலவை அணுகுமுறை

TypeScript ஒற்றை மரபுரிமையை மட்டுமே அனுமதிப்பதால், பல ஆதாரங்களில் இருந்து குறியீட்டை மீண்டும் பயன்படுத்த விரும்பினால் என்ன செய்வது? இங்குதான் கலவை முறை வருகிறது. கலவைகள் என்பது ஒரு கட்டமைப்பாளரை எடுத்து புதிய செயல்பாடுகளுடன் அதை நீட்டிக்கும் ஒரு புதிய கட்டமைப்பாளரை வழங்கும் செயல்பாடுகள். இது ஒரு வகுப்பில் திறன்களை "கலக்க" அனுமதிக்கும் கலவையின் ஒரு வடிவம்.

பயன்பாட்டு நிகழ்வு: நீங்கள் பல மாதிரி வகுப்புகளில் `Timestamp` (`createdAt`, `updatedAt` உடன்) மற்றும் `SoftDeletable` (`deletedAt` சொத்து மற்றும் `softDelete()` முறை மூலம்) நடத்தைகளைச் சேர்க்க விரும்புகிறீர்கள்.

            // A Type helper for mixins
type Constructor = new (...args: any[]) => T;

// Timestamp Mixin
function Timestamped(Base: TBase) {
  return class extends Base {
    createdAt: Date = new Date();
    updatedAt: Date = new Date();
  };
}

// SoftDeletable Mixin
function SoftDeletable(Base: TBase) {
  return class extends Base {
    deletedAt: Date | null = null;

    softDelete() {
      this.deletedAt = new Date();
      console.log("Item has been soft deleted.");
    }
  };
}

// Base class
class DocumentModel {
  constructor(public title: string) {}
}

// Create a new class by composing mixins
const UserAccountModel = SoftDeletable(Timestamped(DocumentModel));

const userAccount = new UserAccountModel("My User Account");
console.log(userAccount.title);
console.log(userAccount.createdAt);
userAccount.softDelete();
console.log(userAccount.deletedAt);
            

              
                Copy
              
            
          

முடிவு: எதிர்காலத்தை நிரூபிக்கும் TypeScript பயன்பாடுகளை உருவாக்குதல்

TypeScript இல் பொருள் நோக்கு நிரலாக்கத்தை மாஸ்டர் செய்வது தொடரியலைப் புரிந்துகொள்வதிலிருந்து வடிவமைப்பு தத்துவத்தை ஏற்றுக்கொள்வது வரையிலான ஒரு பயணம். வகுப்பு கட்டமைப்பு, மரபுரிமை மற்றும் கலவை தொடர்பாக நீங்கள் எடுக்கும் தேர்வுகள் உங்கள் பயன்பாட்டின் நீண்ட கால ஆரோக்கியத்தில் ஆழமான தாக்கத்தை ஏற்படுத்துகின்றன.

உங்கள் உலகளாவிய மேம்பாட்டு பயிற்சிக்கு இங்கே முக்கிய குறிப்புகள் உள்ளன:

1. தூண்களுடன் தொடங்கவும்: உறையவைத்தல், அருவமாக்கம், மரபுரிமை மற்றும் பாலிமார்பிசம் பற்றிய உறுதியான புரிதல் உங்களுக்கு இருப்பதை உறுதிப்படுத்தவும். அவை OOP இன் சொற்களஞ்சியம்.
2. மரபுரிமையை விட கலவையை விரும்புகிறேன்: இந்த கொள்கை உங்களை மிகவும் நெகிழ்வான, மட்டு மற்றும் சோதிக்கக்கூடிய குறியீட்டிற்கு அழைத்துச் செல்லும். கலவையுடன் தொடங்கி, ஒரு தெளிவான, நிலையான "is-a" உறவு இருக்கும்போது மட்டுமே மரபுரிமையை அடையுங்கள்.
3. வேலைக்கு சரியான கருவியைப் பயன்படுத்தவும்:
   • ஒரு நிலையான படிநிலையில் உண்மையான சிறப்பு மற்றும் குறியீடு பகிர்வுக்கு மரபுரிமையைப் பயன்படுத்தவும்.
   • சில செயலாக்கத்தைப் பகிரும் போது ஒரு ஒப்பந்தத்தை உறுதிப்படுத்தும் அதே வேளையில், ஒரு வகுப்புக் குடும்பத்திற்கு ஒரு பொதுவான தளத்தை வரையறுக்க சுருக்க வகுப்புகளைப் பயன்படுத்தவும்.
   • எந்தவொரு வகுப்பாலும் செயல்படுத்தக்கூடிய நடத்தைக்கான ஒப்பந்தங்களை வரையறுக்க இடைமுகங்களைப் பயன்படுத்தவும், தீவிர பிரிவினையை ஊக்குவிக்கவும்.
   • ஒற்றை மரபுரிமையின் வரம்புகளை சமாளித்து, பல ஆதாரங்களில் இருந்து செயல்பாடுகளை ஒரு வகுப்பில் இணைக்க வேண்டியிருக்கும் போது கலவைகளைப் பயன்படுத்தவும்.

இந்த முறைகளைப் பற்றி விமர்சன ரீதியாக சிந்திப்பதன் மூலமும், அவற்றின் வர்த்தகங்களை புரிந்துகொள்வதன் மூலமும், இன்று சக்திவாய்ந்ததாகவும் திறமையாகவும் இருக்கும் TypeScript பயன்பாடுகளை நீங்கள் கட்டமைக்க முடியும், ஆனால் பல ஆண்டுகளாக மாற்றியமைக்க, விரிவாக்க மற்றும் பராமரிக்க எளிதானது - உலகில் நீங்கள் அல்லது உங்கள் குழு எங்கிருந்தாலும்.